// @ts-nocheck
/*import i18n from "@root/i18n";

// 由于服务端中用户群体广泛，来源多样，建议在每个 t 函数中显式传入当前用户的语言标识，以确保多语言内容能够正确匹配用户所需的语言版本。
console.log("(server)：", i18n.t("welcome_game", { lng: "zh-CN" }));
console.log("(server)：", i18n.t("welcome_ap", { lng: "en" }));
*/

// 现代化科研基地建造函数（完整空心分层版）
function buildScienceBase(voxels) {
    const CENTER_X = 128;
    const CENTER_Z = 128;
    const BASE_HEIGHT = 90;
    
    // 1. 清理并准备科技感地基
    cubefill(voxels, 0, 9, 0, 256, 118, 256, "air");
    cubefill(voxels, 0, 8, 0, 256, 1, 256, ["lab_material_09", "lab_material_10", "lab_material_11"]);
    
    // 2. 建造中央科研塔（空心版）
    buildHollowScienceTower(voxels, CENTER_X, CENTER_Z, BASE_HEIGHT);
    
    // 3. 建造量子实验室（空心版）
    buildHollowQuantumLab(voxels, CENTER_X-90, CENTER_Z-90, 35);
    buildHollowQuantumLab(voxels, CENTER_X+90, CENTER_Z+90, 35);
    
    // 4. 建造生物实验室（空心版）
    buildHollowBioLab(voxels, CENTER_X-70, CENTER_Z+70, 30);
    buildHollowBioLab(voxels, CENTER_X+70, CENTER_Z-70, 30);
    
    // 5. 建造发射平台
    buildLaunchPad(voxels, CENTER_X, CENTER_Z+130, 45);
    
    // 6. 建造防御阵列
    buildDefenseArray(voxels, CENTER_X, CENTER_Z, 110);
    
    // 7. 建造科研交通网络
    buildScienceRoads(voxels, CENTER_X, CENTER_Z);
    
    // 8. 添加科技照明系统
    buildTechLighting(voxels);
}

// 空心科研塔（带分层内部结构）
function buildHollowScienceTower(voxels, x, z, height) {
    // 地基（复合科技材料）
    cubefill(voxels, x-16, 9, z-16, 32, 4, 32, [
        "lab_material_01", 
        "lab_material_02",
        "lab_material_03"
    ]);
    
    // 主体结构（空心设计）
    for (let y = 13; y < height; y++) {
        // 外墙（带窗户）
        for (let dx = -14; dx <= 14; dx++) {
            for (let dz = -14; dz <= 14; dz++) {
                if ((Math.abs(dx) === 14 || Math.abs(dz) === 14) && 
                    (y % 6 < 3 || Math.abs(dx+dz) % 4 !== 0)) {
                    const mat = y % 12 < 6 ? "lab_material_04" : "lab_material_05";
                    voxels.setVoxel(x+dx, y, z+dz, mat);
                }
            }
        }
        
        // 每6层一个平台（带内部楼层）
        if (y % 12 === 0) {
            // 外部平台
            cubefill(voxels, x-16, y, z-16, 32, 1, 32, "lab_material_06");
            
            // 内部楼层（带中心空洞）
            for (let dx = -12; dx <= 12; dx++) {
                for (let dz = -12; dz <= 12; dz++) {
                    if (Math.abs(dx) > 3 || Math.abs(dz) > 3) {
                        voxels.setVoxel(x+dx, y+1, z+dz, "lab_material_07");
                    }
                }
            }
            
            // 平台装饰（实验室屏幕）
            for (let angle = 0; angle < Math.PI*2; angle += Math.PI/8) {
                const offsetX = Math.round(15 * Math.cos(angle));
                const offsetZ = Math.round(15 * Math.sin(angle));
                voxels.setVoxel(x+offsetX, y+1, z+offsetZ, "lab_screen");
            }
            
            // 添加螺旋楼梯
            buildSpiralStairs(voxels, x-10, y+1, z-10, 12);
        }
    }
    
    // 顶部观测平台（空心设计）
    for (let y = height; y < height+5; y++) {
        for (let dx = -8; dx <= 8; dx++) {
            for (let dz = -8; dz <= 8; dz++) {
                if (Math.abs(dx) === 8 || Math.abs(dz) === 8 || 
                    (y === height && Math.abs(dx) < 6 && Math.abs(dz) < 6)) {
                    voxels.setVoxel(x+dx, y, z+dz, "lab_material_08");
                }
            }
        }
    }
    
    // 能量发射器（空心结构）
    for (let i = 0; i < 5; i++) {
        const size = 5-2*i;
        for (let dx = -size; dx <= size; dx++) {
            for (let dz = -size; dz <= size; dz++) {
                if (Math.abs(dx) === size || Math.abs(dz) === size) {
                    voxels.setVoxel(x+dx, height+6+i, z+dz, "lab_material_09");
                }
            }
        }
    }
    
    // 内部核心（空心柱+电缆）
    for (let y = 15; y < height; y++) {
        for (let dx = -2; dx <= 2; dx++) {
            for (let dz = -2; dz <= 2; dz++) {
                if (Math.abs(dx) === 2 || Math.abs(dz) === 2) {
                    voxels.setVoxel(x+dx, y, z+dz, "lab_wire");
                }
            }
        }
        voxels.setVoxel(x, y, z, "lab_material_15");
    }
}

// 空心量子实验室
function buildHollowQuantumLab(voxels, x, z, size) {
    // 主结构（六边形空心设计）
    for (let y = 9; y < 15; y++) {
        const radius = size - (y-9)*2;
        for (let dx = -radius; dx <= radius; dx++) {
            for (let dz = -radius; dz <= radius; dz++) {
                if (Math.abs(dx) + Math.abs(dz) <= radius && 
                   (Math.abs(dx) + Math.abs(dz) > radius-3 || y % 3 === 0)) {
                    voxels.setVoxel(x+dx, y, z+dz, "lab_material_10");
                }
            }
        }
    }
    
    // 内部楼层（带中心空洞）
    for (let y = 12; y < 15; y += 3) {
        for (let dx = -size+3; dx <= size-3; dx++) {
            for (let dz = -size+3; dz <= size-3; dz++) {
                if (Math.abs(dx) + Math.abs(dz) <= size-3 && 
                   Math.abs(dx) + Math.abs(dz) > 5) {
                    voxels.setVoxel(x+dx, y, z+dz, "lab_material_11");
                }
            }
        }
    }
    
    // 量子核心（空心球体）
    for (let y = 15; y < 30; y++) {
        const radius = Math.round(8 * Math.sin((y-15)/15 * Math.PI));
        for (let dx = -radius; dx <= radius; dx++) {
            for (let dz = -radius; dz <= radius; dz++) {
                const dist = dx*dx + dz*dz;
                if (dist <= radius*radius && dist > (radius-2)*(radius-2)) {
                    voxels.setVoxel(x+dx, y, z+dz, y % 3 === 0 ? "lab_material_12" : "lab_material_13");
                }
            }
        }
    }
    
    // 外部连接器（带实验室屏幕）
    for (let angle = 0; angle < Math.PI*2; angle += Math.PI/3) {
        const offsetX = Math.round(size * Math.cos(angle));
        const offsetZ = Math.round(size * Math.sin(angle));
        cubefill(voxels, x+offsetX-1, 9, z+offsetZ-1, 3, 10, 3, "lab_material_14");
        voxels.setVoxel(x+offsetX, 19, z+offsetZ, "lab_screen");
    }
}

// 空心生物实验室
function buildHollowBioLab(voxels, x, z, size) {
    // 主建筑（有机形态空心设计）
    for (let y = 9; y < 25; y++) {
        const radius = size * (0.6 + 0.2 * Math.sin(y/5));
        for (let dx = -radius; dx <= radius; dx++) {
            for (let dz = -radius; dz <= radius; dz++) {
                const dist = dx*dx + dz*dz;
                if (dist <= radius*radius * (0.8 + 0.2 * Math.sin(dx/3 + dz/3)) &&
                   (dist > (radius*0.7)*(radius*0.7) || y % 4 === 0)) {
                    voxels.setVoxel(x+dx, y, z+dz, "lab_material_14");
                }
            }
        }
    }
    
    // 温室穹顶（彩色玻璃）
    for (let y = 25; y < 35; y++) {
        const radius = size * (1 - (y-25)/10);
        for (let dx = -radius; dx <= radius; dx++) {
            for (let dz = -radius; dz <= radius; dz++) {
                if (dx*dx + dz*dz <= radius*radius) {
                    voxels.setVoxel(x+dx, y, z+dz, "color_glass");
                }
            }
        }
    }
    
    // 内部培养舱（分层设计）
    for (let i = 0; i < 4; i++) {
        const angle = i * Math.PI/2;
        const offsetX = Math.round(size/2 * Math.cos(angle));
        const offsetZ = Math.round(size/2 * Math.sin(angle));
        
        // 空心玻璃培养舱
        for (let ly = 10; ly < 17; ly++) {
            for (let lx = -3; lx <= 3; lx++) {
                for (let lz = -3; lz <= 3; lz++) {
                    if (Math.abs(lx) === 3 || Math.abs(lz) === 3 || 
                       (ly === 10 && Math.abs(lx) < 3 && Math.abs(lz) < 3)) {
                        voxels.setVoxel(x+offsetX+lx, ly, z+offsetZ+lz, "glass");
                    }
                }
            }
        }
        
        // 内部培养液（水方块）
        cubefill(voxels, x+offsetX-2, 11, z+offsetZ-2, 5, 5, 5, "water");
    }
}

// 螺旋楼梯建造函数
function buildSpiralStairs(voxels, startX, startY, startZ, height) {
    const centerX = startX + 4;
    const centerZ = startZ + 4;
    
    for (let y = 0; y < height; y++) {
        const angle = y * Math.PI/4;
        const stepX = Math.round(3 * Math.cos(angle));
        const stepZ = Math.round(3 * Math.sin(angle));
        
        // 楼梯台阶（使用实验室材料）
        for (let i = 0; i < 3; i++) {
            voxels.setVoxel(
                centerX + Math.round(stepX * (1 + i/3)), 
                startY + y, 
                centerZ + Math.round(stepZ * (1 + i/3)), 
                "lab_material_06"
            );
        }
        
        // 中心支柱（不锈钢材质）
        voxels.setVoxel(centerX, startY + y, centerZ, "stainless_steel");
    }
}

// 发射平台
function buildLaunchPad(voxels, x, z, size) {
    // 平台主体（实验室材料）
    cubefill(voxels, x-size/2, 9, z-size/2, size, 3, size, "lab_material_06");
    
    // 发射轨道（不锈钢材质）
    for (let angle = 0; angle < Math.PI*2; angle += Math.PI/4) {
        for (let r = 5; r < size/2; r += 5) {
            const offsetX = Math.round(r * Math.cos(angle));
            const offsetZ = Math.round(r * Math.sin(angle));
            voxels.setVoxel(x+offsetX, 12, z+offsetZ, "stainless_steel");
        }
    }
    
    // 能量矩阵（发光方块）
    for (let y = 12; y < 25; y++) {
        const radius = size/2 - (y-12)/3;
        for (let angle = 0; angle < Math.PI*2; angle += Math.PI/8) {
            const offsetX = Math.round(radius * Math.cos(angle));
            const offsetZ = Math.round(radius * Math.sin(angle));
            voxels.setVoxel(x+offsetX, y, z+offsetZ, "white_light");
        }
    }
    
    // 发射塔（实验室材料）
    cubefill(voxels, x-2, 25, z-2, 5, 30, 5, "lab_material_09");
    cubefill(voxels, x-4, 55, z-4, 9, 1, 9, "lab_material_10");
}

// 防御阵列
function buildDefenseArray(voxels, centerX, centerZ, radius) {
    // 防御节点（深色砖块）
    for (let angle = 0; angle < Math.PI*2; angle += Math.PI/6) {
        const x = Math.round(centerX + radius * Math.cos(angle));
        const z = Math.round(centerZ + radius * Math.sin(angle));
        
        // 防御塔
        cubefill(voxels, x-4, 9, z-4, 9, 25, 9, "dark_brick_01");
        
        // 能量炮（红色灯光）
        for (let y = 34; y < 44; y++) {
            voxels.setVoxel(x, y, z, "red_light");
            if (y % 3 === 0) {
                cubefill(voxels, x-1, y, z-1, 3, 1, 3, "lab_material_13");
            }
        }
    }
    
    // 能量屏障（交替颜色玻璃）
    for (let y = 15; y < 30; y++) {
        for (let angle = 0; angle < Math.PI*2; angle += 0.05) {
            const x = Math.round(centerX + radius * Math.cos(angle));
            const z = Math.round(centerZ + radius * Math.sin(angle));
            voxels.setVoxel(x, y, z, y % 4 < 2 ? "blue_glass" : "purple_glass");
        }
    }
}

// 科研道路
function buildScienceRoads(voxels, centerX, centerZ) {
    // 主干道（发光地板）
    for (let x = 0; x < 256; x++) {
        for (let z = 0; z < 256; z++) {
            if (Math.abs(x-centerX) < 6 || Math.abs(z-centerZ) < 6) {
                voxels.setVoxel(x, 9, z, "ledfloor01");
            }
        }
    }
    
    // 连接通道（悬浮设计）
    for (let angle = Math.PI/4; angle < Math.PI*2; angle += Math.PI/2) {
        const startX = Math.round(centerX + 40 * Math.cos(angle));
        const startZ = Math.round(centerZ + 40 * Math.sin(angle));
        const endX = Math.round(centerX + 90 * Math.cos(angle));
        const endZ = Math.round(centerZ + 90 * Math.sin(angle));
        
        for (let t = 0; t <= 1; t += 0.01) {
            const x = Math.round(startX + (endX-startX)*t);
            const z = Math.round(startZ + (endZ-startZ)*t);
            const y = 15 + Math.round(5 * Math.sin(t * Math.PI));
            
            cubefill(voxels, x-2, y, z-2, 5, 1, 5, "lab_material_14");
            cubefill(voxels, x-1, y+1, z-1, 3, 1, 3, "glass");
        }
    }
}

// 科技照明系统
function buildTechLighting(voxels) {
    // 建筑轮廓灯（多彩灯光）
    for (let y = 15; y < 100; y += 10) {
        for (let x = 20; x < 236; x += 5) {
            voxels.setVoxel(x, y, 20, "indigo_light");
            voxels.setVoxel(x, y, 236, "mint_green_light");
            voxels.setVoxel(20, y, x, "orange_light");
            voxels.setVoxel(236, y, x, "pink_light");
        }
    }
    
    // 道路指示灯（暖黄色灯光）
    for (let x = 15; x < 241; x += 30) {
        for (let z = 15; z < 241; z += 30) {
            cubefill(voxels, x-1, 10, z-1, 3, 3, 3, "warm_yellow_light");
        }
    }
    
    // 建筑顶部信标（白色强光）
    const buildings = [
        [128, 128], [90, 90], [166, 166], [70, 186], [186, 70]
    ];
    buildings.forEach(([x, z]) => {
        for (let y = 100; y < 120; y++) {
            voxels.setVoxel(x, y, z, "white_light");
        }
    });
}

// 立方体填充函数（支持材质数组）
function cubefill(voxels, startX, startY, startZ, sizeX, sizeY, sizeZ, material = "stone") {
    const materials = Array.isArray(material) ? material : [material];
    const endX = startX + sizeX;
    const endY = startY + sizeY;
    const endZ = startZ + sizeZ;

    for (let x = startX; x < endX; x++) {
        for (let y = startY; y < endY; y++) {
            for (let z = startZ; z < endZ; z++) {
                const selectedMat = materials[Math.floor(Math.random() * materials.length)];
                voxels.setVoxel(x, y, z, selectedMat);
            }
        }
    }
}

// 执行建造
buildScienceBase(voxels);